import random,time
from collections import defaultdict

newwanjia = ''
zhuangjia = '东边'
source = []
xianglin = []
east = []
north = []
west = []
south = []

eastdic = {}
northdic = {}
westdic = {}
southdic = {}

shouzhuangjialist = []
wanjiaindex = 0
qupai = 1
shengyu = []
muqianchupai = 0
panduanpeng = 0


def list_duplicates(seq):

    tally = defaultdict(list)
    for i, item in enumerate(seq):
        tally[item].append(i)
    return ((key, locs) for key, locs in tally.items()
            if len(locs) > 1)


def paixu_pai(shouzhuangjia):
    global  wanjiaindex, shouzhuangjialist, qupai, shengyu, muqianchupai, xianglin, newwanjia, source
    xianglin = []
    #print('目前的玩家是{}从新排序：'.format(shouzhuangjia))
    wanjiapai = globals()[shouzhuangjia]
    wanjiapai.sort()
    #print('{}玩家的牌：'.format(shouzhuangjia), wanjiapai)

    source = wanjiapai

    fourdelindexlist = []
    threedelindexlist = []
    twodelindexlist = []

    twolist = []
    threelist = []
    fourlist = []

    fourdelllist = []
    threedelllist = []
    twodelllist = []

#   查询4同牌------start-------------------------------------------------------
    '''''
    # 判断4个相同牌
    for dup in sorted(list_duplicates(source)):
        #print(dup[0], len(dup[1]), dup[1])
        if len(dup[1]) == 4:
            fourlist.append(dup[0])
            fourdelindexlist.append(dup[1])
    #print(fourdelindexlist)
    #print(fourlist)
    for zuhelist in fourdelindexlist:
        for zuhefen in zuhelist:
            fourdelllist.append(zuhefen)
    #print('组合4个要删除的列表下标：', fourdelllist)

    tmp = [i for num, i in enumerate(source) if num not in fourdelllist]
    #print(f"最终去除4同牌列结果：{tmp}")
    source = tmp
    '''
#   查询4同牌------end-------------------------------------------------------

#   查询3同牌------start-------------------------------------------------------
    for dup in sorted(list_duplicates(source)):
        #print(dup[0], len(dup[1]), dup[1])
        if len(dup[1]) == 3:
            threelist.append(dup[0])
            threedelindexlist.append(dup[1])
    #print(threedelindexlist)
    #print(threelist)

    for zuhelist in threedelindexlist:
        for zuhefen in zuhelist:
            threedelllist.append(zuhefen)
    #print('组合3个要删除的列表下标：', threedelllist)

    tmp = [i for num, i in enumerate(source) if num not in threedelllist]
    #print(f"最终去除3同牌列结果：{tmp}")
    source = tmp
#   查询3同牌------end-------------------------------------------------------

#   查询顺子牌------start-------------------------------------------------------
    allshunlist = []
    for i in range(0, 4):
        s = []  # 空栈
        shunzilist = []
        xianglinlist = []
        for i in sorted(set(source)):
            if len(s) == 0 or s[-1] + 1 == i:
                s.append(i)  # 入栈
            else:
                if len(s) >= 2:
                    # #print(s)
                    pass
                s = []  # 清空
                s.append(i)  # 入栈
            # 最后一轮，需判断下
            if len(s) > 2:
                #print(s[0:3])
                shunzilist.append(s[0:3])
        # #print(shunzilist)
        shunzilist2 = []
        for i in shunzilist:
            if i not in shunzilist2:
                shunzilist2.append(i)
        #print(shunzilist2)
        all_shunzilist = []
        for shunzi in shunzilist2:
            for shunzifen in shunzi:
                all_shunzilist.append(shunzifen)
        #print(all_shunzilist)

        for i in all_shunzilist:
            allshunlist.append(i)
            source.remove(i)
    #print('去除顺子剩余：', source)
    #print('全部顺子：', allshunlist)

#   查询顺子牌------end-------------------------------------------------------

#   查询对子牌------start-------------------------------------------------------
    for dup in sorted(list_duplicates(source)):
        #print(dup[0], len(dup[1]), dup[1])
        if len(dup[1]) == 2:
            twolist.append(dup[0])
            twodelindexlist.append(dup[1])
    #print(twodelindexlist)
    #print(twolist)

    for zuhelist in twodelindexlist:
        for zuhefen in zuhelist:
            twodelllist.append(zuhefen)
    #print('组合2个要删除的列表下标：', twodelllist)

    tmp = [i for num, i in enumerate(source) if num not in twodelllist]
    #print(f"最终去除对子牌列结果：{tmp}")
    source = tmp
#   查询对子牌------end--------------------------------------------------------------------------

#   查询相邻牌------start---------------------------------------------------------------------------
    l1 = []
    for x in sorted(set(source)):
        l1.append(x)
        if x + 1 not in source:
            if len(l1) != 1:
                for l1 in l1:
                    xianglin.append(l1)
            l1 = []
#   查询相邻牌------end-------------------------------------------------------------------------

    feipai = set(source) - set(xianglin)
    feipai = list(feipai)
    feipai = xianglin + feipai
    #print('相邻牌：', xianglin)
    #print('废弃的牌：', feipai)


    zhengtidic = {"threelist":threelist, "shunzi":allshunlist, "twolist":twolist, "feipai":feipai}
    globals()[shouzhuangjia + 'dic'] = zhengtidic

    #print('整体排序后的牌：',zhengtidic)


    return


def FaPai():
    wan_list = []
    for wan in range(1, 10):  #1-10代表万
        pai = wan
        for zeng in range(0, 4):
            wan_list.append(pai)

    bing_list = []
    for bing in range(21, 30): #21-30代表饼
        pai = bing
        for zeng in range(0, 4):
            bing_list.append(pai)

    tiao_list = []
    for tiao in range(41, 50):  #41-50代表条
        pai = tiao
        for zeng in range(0, 4):
            bing_list.append(pai)

    pian_list = []
    for pian in [60, 70, 80]:  #60代表发财   70代表红中  80代表白板
        for zeng in range(0, 4):
            bing_list.append(pian)

    all_pai = wan_list + bing_list + tiao_list + pian_list
    random.shuffle(all_pai)
    # #print(len(all_pai))
    # #print(all_pai)
    return all_pai


def QiPai():
    global zhuangjia, east, north, west, south,newwanjia,shouzhuangjialist,shengyu

    morenzhuangjia = ['east', 'north', 'west', 'south']
    zhuangjia = random.choice(morenzhuangjia)
    #print('这局随机庄家为：', zhuangjia)
    suijishaizi = random.choice(range(1, 32))
    #print('随机筛子为：{}'.format(suijishaizi))
    all_pai = FaPai()
    # #print('正常牌：',all_pai)
    all_pai = all_pai[suijishaizi * 2:121] + all_pai[0:suijishaizi * 2]
    #print('所有牌：', all_pai)

    zhuangjiaindex = morenzhuangjia.index(zhuangjia)
    #print('目前庄家在第{}个'.format(zhuangjiaindex))

    shouzhuangjialist = morenzhuangjia[zhuangjiaindex:10] + morenzhuangjia[0:zhuangjiaindex]
    #print('刷新庄家排序：', shouzhuangjialist)
    newwanjia = shouzhuangjialist[0]
    #print('初始当前玩家为：',newwanjia)
    for shouzhuangjia in shouzhuangjialist:
        shuangindex = shouzhuangjialist.index(shouzhuangjia)
        if shuangindex == 0:
            globals()[shouzhuangjia] = all_pai[0:4] + all_pai[16:20] + all_pai[32:36] + list(all_pai[48:49])
        if shuangindex == 1:
            globals()[shouzhuangjia] = all_pai[4:8] + all_pai[20:24] + all_pai[36:40] + list(all_pai[49:50])
        if shuangindex == 2:
            globals()[shouzhuangjia] = all_pai[8:12] + all_pai[24:28] + all_pai[40:44] + list(all_pai[50:51])
        if shuangindex == 3:
            globals()[shouzhuangjia] = all_pai[12:16] + all_pai[28:32] + all_pai[44:48] + list(all_pai[51:52])
        #print(paixu_pai(shouzhuangjia))

    #print('东边牌：', east)
    #print('北边牌：', north)
    #print('西边牌：', west)
    #print('南边牌：', south)

    shengyu = all_pai[52:130]
    #print('剩余牌数量：', len(shengyu),shengyu)

    qianpai = all_pai[0:52]
    qianpai.sort()
    fawanpai = east + north + west + south
    fawanpai.sort()
    #print('所有牌：', qianpai)
    #print(len(fawanpai), '起的牌：', fawanpai)
    if fawanpai == qianpai:
        #print('起牌正确')
    else:
        #print('起牌有问题')

    yanzhengzongpai = fawanpai + shengyu
    #print('长度：', len(yanzhengzongpai), '验证的总牌：', yanzhengzongpai)
    yanzhengzongpai.sort()
    all_pai.sort()

    #print(len(all_pai), all_pai)
    #print(len(yanzhengzongpai), yanzhengzongpai)

    if yanzhengzongpai == all_pai:
        #print('总牌数对齐')
    else:
        #print('未对齐')

    return suijishaizi




def Bot():
    global newwanjia,wanjiaindex,shouzhuangjialist,qupai,shengyu,muqianchupai,panduanpeng
    #print(QiPai())

    #print('这局随机庄家为：', zhuangjia)
    #print('东边玩家初始分配牌：', eastdic)
    #print('北边玩家初始分配牌：', northdic)
    #print('西边玩家初始分配牌：', westdic)
    #print('南边玩家初始分配牌：', southdic)

    #print('刷新庄家排序：', shouzhuangjialist)
    #print('初始当前玩家为：', newwanjia)
    while True:
        #print('还有剩余所有牌：',shengyu)
        wanjiaindex = shouzhuangjialist.index(newwanjia)
        #print(wanjiaindex)
        muqianwanjia = shouzhuangjialist[wanjiaindex]
        #print(globals()[muqianwanjia])
        #print('目前玩家是：{}开始出牌'.format(newwanjia))

        if len(shengyu) == 0:
            #print('所有牌起完了，和局，开始准备下一局')
            #print('剩余所有牌：',shengyu)
            break
        else:
            #print('原本玩家牌列',globals()[muqianwanjia])
            if qupai == 1:
                globals()[newwanjia] = globals()[muqianwanjia] + shengyu[0:1]
                del shengyu[0]
                globals()[muqianwanjia].sort()
            #print('剩余牌：',shengyu)
            paixu_pai(newwanjia)
            #print('起一张牌后字典：', globals()[muqianwanjia + 'dic'])

            if len(globals()[muqianwanjia+'dic']['feipai']) ==0:
                #print('废牌长度等于0')
                if len(globals()[muqianwanjia+'dic']['twolist']) ==1:
                    #print('废牌长度等于0，判断对子长度，只有一个对子所以胡了')
                    break
                else:
                    continue

            else:
                #print('废牌长度不等于0，表示不能胡，继续出废牌')
                suijifeipai = globals()[newwanjia + 'dic']['feipai']
                suijifeipai = suijifeipai[-1]
                #print('现在轮到{}随机出一张废牌：'.format(newwanjia), suijifeipai)

                globals()[newwanjia].remove(suijifeipai)
                #print('出牌后删除此废牌并重新排序')
                paixu_pai(newwanjia)
                muqianchupai = suijifeipai
                muqianchupailist = '['+str(muqianchupai)+']'
                muqianchupailist = eval(muqianchupailist)
                #print('目前出牌{},开始判断下3家是否能碰'.format(muqianchupai))
                #print('目前玩家下标是index:',wanjiaindex)
                if wanjiaindex == 0:
                    xiasanjia = [1,2,3]
                if wanjiaindex == 1:
                    xiasanjia = [2,3,0]
                if wanjiaindex == 2:
                    xiasanjia = [3,0,1]
                if wanjiaindex == 3:
                    xiasanjia = [0,1,2]
                #print('下三家列表下标：',xiasanjia)
                for xiajia in xiasanjia:
                    pengwanjia = shouzhuangjialist[xiajia]
                    #print(pengwanjia)
                    if muqianchupai in globals()[pengwanjia + 'dic']['twolist']:
                        #print('{}玩家可以碰'.format(pengwanjia))
                        newwanjia = pengwanjia
                        wanjiaindex = shouzhuangjialist.index(pengwanjia)
                        qupai = 0
                        globals()[pengwanjia] = globals()[pengwanjia] + muqianchupailist
                        paixu_pai(pengwanjia)
                        #print('碰的玩家将牌拿来重新排序dic：',globals()[pengwanjia + 'dic'])
                        panduanpeng = 1

                        break
                    else:
                        qupai = 1
                        panduanpeng = 0
                        #print('{}玩家不可以碰'.format(pengwanjia))

                if panduanpeng == 1:
                    #print('判断碰为1')
                    continue
                #print("走到这步说明下三家碰不了")
                newwanjia = shouzhuangjialist[xiasanjia[0]]
                qupai = 1
                time.sleep(0)
                continue












        '''''
            #print('庄家开始出牌')
        
            suijixianglin = globals()[newwanjia + 'dic']['xianglin']
            suijifeipai = globals()[newwanjia + 'dic']['feipai']
            if len(suijifeipai) > 0:
                suijifeipai = random.choice(suijifeipai)
                #print('现在轮到{}随机出一张废牌：'.format(newwanjia),suijifeipai)
        
                globals()[newwanjia] = globals()[newwanjia].remove(suijifeipai)
                #print('出牌后删除此废牌并重新排序')
        
        
        
                #print(globals()[newwanjia])
                #print(globals()[newwanjia + 'dic'])
            elif len(suijixianglin) > 0:
                suijixianglin = random.choice(suijixianglin)
                #print('现在轮到{}随机出一张牌,无废牌开始随机出相邻牌：'.format(newwanjia), suijixianglin)
                '''



    return

#print(Bot())






